/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package gmovil_jpa.controladores;

import gmovil_jpa.controladores.exceptions.IllegalOrphanException;
import gmovil_jpa.controladores.exceptions.NonexistentEntityException;
import gmovil_jpa.entidades.Factura;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import gmovil_jpa.entidades.Usuario;
import gmovil_jpa.entidades.PuntoVenta;
import gmovil_jpa.entidades.TipoPlazoPago;
import gmovil_jpa.entidades.Cliente;
import gmovil_jpa.entidades.Empleado;
import gmovil_jpa.entidades.DetalleFacturaArticulo;
import java.util.ArrayList;
import java.util.List;
import gmovil_jpa.entidades.Comision;
import gmovil_jpa.entidades.DetalleFacturaPlan;
import gmovil_jpa.entidades.ReciboCaja;

/**
 *
 * @author castlerock
 */
public class FacturaJpaController {

    public FacturaJpaController() {
        emf = Persistence.createEntityManagerFactory("gmovil_jpaPU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Factura factura) {
        if (factura.getDetalleFacturaArticuloList() == null) {
            factura.setDetalleFacturaArticuloList(new ArrayList<DetalleFacturaArticulo>());
        }
        if (factura.getComisionList() == null) {
            factura.setComisionList(new ArrayList<Comision>());
        }
        if (factura.getDetalleFacturaPlanList() == null) {
            factura.setDetalleFacturaPlanList(new ArrayList<DetalleFacturaPlan>());
        }
        if (factura.getReciboCajaList() == null) {
            factura.setReciboCajaList(new ArrayList<ReciboCaja>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Usuario usuario = factura.getUsuario();
            if (usuario != null) {
                usuario = em.getReference(usuario.getClass(), usuario.getIdUsuario());
                factura.setUsuario(usuario);
            }
            Usuario usuario1 = factura.getUsuario1();
            if (usuario1 != null) {
                usuario1 = em.getReference(usuario1.getClass(), usuario1.getIdUsuario());
                factura.setUsuario1(usuario1);
            }
            PuntoVenta puntoVenta = factura.getPuntoVenta();
            if (puntoVenta != null) {
                puntoVenta = em.getReference(puntoVenta.getClass(), puntoVenta.getIdPuntoVenta());
                factura.setPuntoVenta(puntoVenta);
            }
            TipoPlazoPago tipoPlazoPago = factura.getTipoPlazoPago();
            if (tipoPlazoPago != null) {
                tipoPlazoPago = em.getReference(tipoPlazoPago.getClass(), tipoPlazoPago.getIdTipoPlazoPago());
                factura.setTipoPlazoPago(tipoPlazoPago);
            }
            Cliente cliente = factura.getCliente();
            if (cliente != null) {
                cliente = em.getReference(cliente.getClass(), cliente.getIdCliente());
                factura.setCliente(cliente);
            }
            Empleado empleado = factura.getEmpleado();
            if (empleado != null) {
                empleado = em.getReference(empleado.getClass(), empleado.getIdEmpleado());
                factura.setEmpleado(empleado);
            }
            List<DetalleFacturaArticulo> attachedDetalleFacturaArticuloList = new ArrayList<DetalleFacturaArticulo>();
            for (DetalleFacturaArticulo detalleFacturaArticuloListDetalleFacturaArticuloToAttach : factura.getDetalleFacturaArticuloList()) {
                detalleFacturaArticuloListDetalleFacturaArticuloToAttach = em.getReference(detalleFacturaArticuloListDetalleFacturaArticuloToAttach.getClass(), detalleFacturaArticuloListDetalleFacturaArticuloToAttach.getIdDetalleFacturaArticulo());
                attachedDetalleFacturaArticuloList.add(detalleFacturaArticuloListDetalleFacturaArticuloToAttach);
            }
            factura.setDetalleFacturaArticuloList(attachedDetalleFacturaArticuloList);
            List<Comision> attachedComisionList = new ArrayList<Comision>();
            for (Comision comisionListComisionToAttach : factura.getComisionList()) {
                comisionListComisionToAttach = em.getReference(comisionListComisionToAttach.getClass(), comisionListComisionToAttach.getIdComision());
                attachedComisionList.add(comisionListComisionToAttach);
            }
            factura.setComisionList(attachedComisionList);
            List<DetalleFacturaPlan> attachedDetalleFacturaPlanList = new ArrayList<DetalleFacturaPlan>();
            for (DetalleFacturaPlan detalleFacturaPlanListDetalleFacturaPlanToAttach : factura.getDetalleFacturaPlanList()) {
                detalleFacturaPlanListDetalleFacturaPlanToAttach = em.getReference(detalleFacturaPlanListDetalleFacturaPlanToAttach.getClass(), detalleFacturaPlanListDetalleFacturaPlanToAttach.getIdDetalleFacturaPlan());
                attachedDetalleFacturaPlanList.add(detalleFacturaPlanListDetalleFacturaPlanToAttach);
            }
            factura.setDetalleFacturaPlanList(attachedDetalleFacturaPlanList);
            List<ReciboCaja> attachedReciboCajaList = new ArrayList<ReciboCaja>();
            for (ReciboCaja reciboCajaListReciboCajaToAttach : factura.getReciboCajaList()) {
                reciboCajaListReciboCajaToAttach = em.getReference(reciboCajaListReciboCajaToAttach.getClass(), reciboCajaListReciboCajaToAttach.getIdReciboCaja());
                attachedReciboCajaList.add(reciboCajaListReciboCajaToAttach);
            }
            factura.setReciboCajaList(attachedReciboCajaList);
            em.persist(factura);
            if (usuario != null) {
                usuario.getFacturaList().add(factura);
                usuario = em.merge(usuario);
            }
            if (usuario1 != null) {
                usuario1.getFacturaList().add(factura);
                usuario1 = em.merge(usuario1);
            }
            if (puntoVenta != null) {
                puntoVenta.getFacturaList().add(factura);
                puntoVenta = em.merge(puntoVenta);
            }
            if (tipoPlazoPago != null) {
                tipoPlazoPago.getFacturaList().add(factura);
                tipoPlazoPago = em.merge(tipoPlazoPago);
            }
            if (cliente != null) {
                cliente.getFacturaList().add(factura);
                cliente = em.merge(cliente);
            }
            if (empleado != null) {
                empleado.getFacturaList().add(factura);
                empleado = em.merge(empleado);
            }
            for (DetalleFacturaArticulo detalleFacturaArticuloListDetalleFacturaArticulo : factura.getDetalleFacturaArticuloList()) {
                Factura oldFacturaOfDetalleFacturaArticuloListDetalleFacturaArticulo = detalleFacturaArticuloListDetalleFacturaArticulo.getFactura();
                detalleFacturaArticuloListDetalleFacturaArticulo.setFactura(factura);
                detalleFacturaArticuloListDetalleFacturaArticulo = em.merge(detalleFacturaArticuloListDetalleFacturaArticulo);
                if (oldFacturaOfDetalleFacturaArticuloListDetalleFacturaArticulo != null) {
                    oldFacturaOfDetalleFacturaArticuloListDetalleFacturaArticulo.getDetalleFacturaArticuloList().remove(detalleFacturaArticuloListDetalleFacturaArticulo);
                    oldFacturaOfDetalleFacturaArticuloListDetalleFacturaArticulo = em.merge(oldFacturaOfDetalleFacturaArticuloListDetalleFacturaArticulo);
                }
            }
            for (Comision comisionListComision : factura.getComisionList()) {
                Factura oldFacturaOfComisionListComision = comisionListComision.getFactura();
                comisionListComision.setFactura(factura);
                comisionListComision = em.merge(comisionListComision);
                if (oldFacturaOfComisionListComision != null) {
                    oldFacturaOfComisionListComision.getComisionList().remove(comisionListComision);
                    oldFacturaOfComisionListComision = em.merge(oldFacturaOfComisionListComision);
                }
            }
            for (DetalleFacturaPlan detalleFacturaPlanListDetalleFacturaPlan : factura.getDetalleFacturaPlanList()) {
                Factura oldFacturaOfDetalleFacturaPlanListDetalleFacturaPlan = detalleFacturaPlanListDetalleFacturaPlan.getFactura();
                detalleFacturaPlanListDetalleFacturaPlan.setFactura(factura);
                detalleFacturaPlanListDetalleFacturaPlan = em.merge(detalleFacturaPlanListDetalleFacturaPlan);
                if (oldFacturaOfDetalleFacturaPlanListDetalleFacturaPlan != null) {
                    oldFacturaOfDetalleFacturaPlanListDetalleFacturaPlan.getDetalleFacturaPlanList().remove(detalleFacturaPlanListDetalleFacturaPlan);
                    oldFacturaOfDetalleFacturaPlanListDetalleFacturaPlan = em.merge(oldFacturaOfDetalleFacturaPlanListDetalleFacturaPlan);
                }
            }
            for (ReciboCaja reciboCajaListReciboCaja : factura.getReciboCajaList()) {
                Factura oldFacturaOfReciboCajaListReciboCaja = reciboCajaListReciboCaja.getFactura();
                reciboCajaListReciboCaja.setFactura(factura);
                reciboCajaListReciboCaja = em.merge(reciboCajaListReciboCaja);
                if (oldFacturaOfReciboCajaListReciboCaja != null) {
                    oldFacturaOfReciboCajaListReciboCaja.getReciboCajaList().remove(reciboCajaListReciboCaja);
                    oldFacturaOfReciboCajaListReciboCaja = em.merge(oldFacturaOfReciboCajaListReciboCaja);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Factura factura) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Factura persistentFactura = em.find(Factura.class, factura.getIdFactura());
            Usuario usuarioOld = persistentFactura.getUsuario();
            Usuario usuarioNew = factura.getUsuario();
            Usuario usuario1Old = persistentFactura.getUsuario1();
            Usuario usuario1New = factura.getUsuario1();
            PuntoVenta puntoVentaOld = persistentFactura.getPuntoVenta();
            PuntoVenta puntoVentaNew = factura.getPuntoVenta();
            TipoPlazoPago tipoPlazoPagoOld = persistentFactura.getTipoPlazoPago();
            TipoPlazoPago tipoPlazoPagoNew = factura.getTipoPlazoPago();
            Cliente clienteOld = persistentFactura.getCliente();
            Cliente clienteNew = factura.getCliente();
            Empleado empleadoOld = persistentFactura.getEmpleado();
            Empleado empleadoNew = factura.getEmpleado();
            List<DetalleFacturaArticulo> detalleFacturaArticuloListOld = persistentFactura.getDetalleFacturaArticuloList();
            List<DetalleFacturaArticulo> detalleFacturaArticuloListNew = factura.getDetalleFacturaArticuloList();
            List<Comision> comisionListOld = persistentFactura.getComisionList();
            List<Comision> comisionListNew = factura.getComisionList();
            List<DetalleFacturaPlan> detalleFacturaPlanListOld = persistentFactura.getDetalleFacturaPlanList();
            List<DetalleFacturaPlan> detalleFacturaPlanListNew = factura.getDetalleFacturaPlanList();
            List<ReciboCaja> reciboCajaListOld = persistentFactura.getReciboCajaList();
            List<ReciboCaja> reciboCajaListNew = factura.getReciboCajaList();
            List<String> illegalOrphanMessages = null;
            for (DetalleFacturaArticulo detalleFacturaArticuloListOldDetalleFacturaArticulo : detalleFacturaArticuloListOld) {
                if (!detalleFacturaArticuloListNew.contains(detalleFacturaArticuloListOldDetalleFacturaArticulo)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain DetalleFacturaArticulo " + detalleFacturaArticuloListOldDetalleFacturaArticulo + " since its factura field is not nullable.");
                }
            }
            for (Comision comisionListOldComision : comisionListOld) {
                if (!comisionListNew.contains(comisionListOldComision)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Comision " + comisionListOldComision + " since its factura field is not nullable.");
                }
            }
            for (DetalleFacturaPlan detalleFacturaPlanListOldDetalleFacturaPlan : detalleFacturaPlanListOld) {
                if (!detalleFacturaPlanListNew.contains(detalleFacturaPlanListOldDetalleFacturaPlan)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain DetalleFacturaPlan " + detalleFacturaPlanListOldDetalleFacturaPlan + " since its factura field is not nullable.");
                }
            }
            for (ReciboCaja reciboCajaListOldReciboCaja : reciboCajaListOld) {
                if (!reciboCajaListNew.contains(reciboCajaListOldReciboCaja)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain ReciboCaja " + reciboCajaListOldReciboCaja + " since its factura field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (usuarioNew != null) {
                usuarioNew = em.getReference(usuarioNew.getClass(), usuarioNew.getIdUsuario());
                factura.setUsuario(usuarioNew);
            }
            if (usuario1New != null) {
                usuario1New = em.getReference(usuario1New.getClass(), usuario1New.getIdUsuario());
                factura.setUsuario1(usuario1New);
            }
            if (puntoVentaNew != null) {
                puntoVentaNew = em.getReference(puntoVentaNew.getClass(), puntoVentaNew.getIdPuntoVenta());
                factura.setPuntoVenta(puntoVentaNew);
            }
            if (tipoPlazoPagoNew != null) {
                tipoPlazoPagoNew = em.getReference(tipoPlazoPagoNew.getClass(), tipoPlazoPagoNew.getIdTipoPlazoPago());
                factura.setTipoPlazoPago(tipoPlazoPagoNew);
            }
            if (clienteNew != null) {
                clienteNew = em.getReference(clienteNew.getClass(), clienteNew.getIdCliente());
                factura.setCliente(clienteNew);
            }
            if (empleadoNew != null) {
                empleadoNew = em.getReference(empleadoNew.getClass(), empleadoNew.getIdEmpleado());
                factura.setEmpleado(empleadoNew);
            }
            List<DetalleFacturaArticulo> attachedDetalleFacturaArticuloListNew = new ArrayList<DetalleFacturaArticulo>();
            for (DetalleFacturaArticulo detalleFacturaArticuloListNewDetalleFacturaArticuloToAttach : detalleFacturaArticuloListNew) {
                detalleFacturaArticuloListNewDetalleFacturaArticuloToAttach = em.getReference(detalleFacturaArticuloListNewDetalleFacturaArticuloToAttach.getClass(), detalleFacturaArticuloListNewDetalleFacturaArticuloToAttach.getIdDetalleFacturaArticulo());
                attachedDetalleFacturaArticuloListNew.add(detalleFacturaArticuloListNewDetalleFacturaArticuloToAttach);
            }
            detalleFacturaArticuloListNew = attachedDetalleFacturaArticuloListNew;
            factura.setDetalleFacturaArticuloList(detalleFacturaArticuloListNew);
            List<Comision> attachedComisionListNew = new ArrayList<Comision>();
            for (Comision comisionListNewComisionToAttach : comisionListNew) {
                comisionListNewComisionToAttach = em.getReference(comisionListNewComisionToAttach.getClass(), comisionListNewComisionToAttach.getIdComision());
                attachedComisionListNew.add(comisionListNewComisionToAttach);
            }
            comisionListNew = attachedComisionListNew;
            factura.setComisionList(comisionListNew);
            List<DetalleFacturaPlan> attachedDetalleFacturaPlanListNew = new ArrayList<DetalleFacturaPlan>();
            for (DetalleFacturaPlan detalleFacturaPlanListNewDetalleFacturaPlanToAttach : detalleFacturaPlanListNew) {
                detalleFacturaPlanListNewDetalleFacturaPlanToAttach = em.getReference(detalleFacturaPlanListNewDetalleFacturaPlanToAttach.getClass(), detalleFacturaPlanListNewDetalleFacturaPlanToAttach.getIdDetalleFacturaPlan());
                attachedDetalleFacturaPlanListNew.add(detalleFacturaPlanListNewDetalleFacturaPlanToAttach);
            }
            detalleFacturaPlanListNew = attachedDetalleFacturaPlanListNew;
            factura.setDetalleFacturaPlanList(detalleFacturaPlanListNew);
            List<ReciboCaja> attachedReciboCajaListNew = new ArrayList<ReciboCaja>();
            for (ReciboCaja reciboCajaListNewReciboCajaToAttach : reciboCajaListNew) {
                reciboCajaListNewReciboCajaToAttach = em.getReference(reciboCajaListNewReciboCajaToAttach.getClass(), reciboCajaListNewReciboCajaToAttach.getIdReciboCaja());
                attachedReciboCajaListNew.add(reciboCajaListNewReciboCajaToAttach);
            }
            reciboCajaListNew = attachedReciboCajaListNew;
            factura.setReciboCajaList(reciboCajaListNew);
            factura = em.merge(factura);
            if (usuarioOld != null && !usuarioOld.equals(usuarioNew)) {
                usuarioOld.getFacturaList().remove(factura);
                usuarioOld = em.merge(usuarioOld);
            }
            if (usuarioNew != null && !usuarioNew.equals(usuarioOld)) {
                usuarioNew.getFacturaList().add(factura);
                usuarioNew = em.merge(usuarioNew);
            }
            if (usuario1Old != null && !usuario1Old.equals(usuario1New)) {
                usuario1Old.getFacturaList().remove(factura);
                usuario1Old = em.merge(usuario1Old);
            }
            if (usuario1New != null && !usuario1New.equals(usuario1Old)) {
                usuario1New.getFacturaList().add(factura);
                usuario1New = em.merge(usuario1New);
            }
            if (puntoVentaOld != null && !puntoVentaOld.equals(puntoVentaNew)) {
                puntoVentaOld.getFacturaList().remove(factura);
                puntoVentaOld = em.merge(puntoVentaOld);
            }
            if (puntoVentaNew != null && !puntoVentaNew.equals(puntoVentaOld)) {
                puntoVentaNew.getFacturaList().add(factura);
                puntoVentaNew = em.merge(puntoVentaNew);
            }
            if (tipoPlazoPagoOld != null && !tipoPlazoPagoOld.equals(tipoPlazoPagoNew)) {
                tipoPlazoPagoOld.getFacturaList().remove(factura);
                tipoPlazoPagoOld = em.merge(tipoPlazoPagoOld);
            }
            if (tipoPlazoPagoNew != null && !tipoPlazoPagoNew.equals(tipoPlazoPagoOld)) {
                tipoPlazoPagoNew.getFacturaList().add(factura);
                tipoPlazoPagoNew = em.merge(tipoPlazoPagoNew);
            }
            if (clienteOld != null && !clienteOld.equals(clienteNew)) {
                clienteOld.getFacturaList().remove(factura);
                clienteOld = em.merge(clienteOld);
            }
            if (clienteNew != null && !clienteNew.equals(clienteOld)) {
                clienteNew.getFacturaList().add(factura);
                clienteNew = em.merge(clienteNew);
            }
            if (empleadoOld != null && !empleadoOld.equals(empleadoNew)) {
                empleadoOld.getFacturaList().remove(factura);
                empleadoOld = em.merge(empleadoOld);
            }
            if (empleadoNew != null && !empleadoNew.equals(empleadoOld)) {
                empleadoNew.getFacturaList().add(factura);
                empleadoNew = em.merge(empleadoNew);
            }
            for (DetalleFacturaArticulo detalleFacturaArticuloListNewDetalleFacturaArticulo : detalleFacturaArticuloListNew) {
                if (!detalleFacturaArticuloListOld.contains(detalleFacturaArticuloListNewDetalleFacturaArticulo)) {
                    Factura oldFacturaOfDetalleFacturaArticuloListNewDetalleFacturaArticulo = detalleFacturaArticuloListNewDetalleFacturaArticulo.getFactura();
                    detalleFacturaArticuloListNewDetalleFacturaArticulo.setFactura(factura);
                    detalleFacturaArticuloListNewDetalleFacturaArticulo = em.merge(detalleFacturaArticuloListNewDetalleFacturaArticulo);
                    if (oldFacturaOfDetalleFacturaArticuloListNewDetalleFacturaArticulo != null && !oldFacturaOfDetalleFacturaArticuloListNewDetalleFacturaArticulo.equals(factura)) {
                        oldFacturaOfDetalleFacturaArticuloListNewDetalleFacturaArticulo.getDetalleFacturaArticuloList().remove(detalleFacturaArticuloListNewDetalleFacturaArticulo);
                        oldFacturaOfDetalleFacturaArticuloListNewDetalleFacturaArticulo = em.merge(oldFacturaOfDetalleFacturaArticuloListNewDetalleFacturaArticulo);
                    }
                }
            }
            for (Comision comisionListNewComision : comisionListNew) {
                if (!comisionListOld.contains(comisionListNewComision)) {
                    Factura oldFacturaOfComisionListNewComision = comisionListNewComision.getFactura();
                    comisionListNewComision.setFactura(factura);
                    comisionListNewComision = em.merge(comisionListNewComision);
                    if (oldFacturaOfComisionListNewComision != null && !oldFacturaOfComisionListNewComision.equals(factura)) {
                        oldFacturaOfComisionListNewComision.getComisionList().remove(comisionListNewComision);
                        oldFacturaOfComisionListNewComision = em.merge(oldFacturaOfComisionListNewComision);
                    }
                }
            }
            for (DetalleFacturaPlan detalleFacturaPlanListNewDetalleFacturaPlan : detalleFacturaPlanListNew) {
                if (!detalleFacturaPlanListOld.contains(detalleFacturaPlanListNewDetalleFacturaPlan)) {
                    Factura oldFacturaOfDetalleFacturaPlanListNewDetalleFacturaPlan = detalleFacturaPlanListNewDetalleFacturaPlan.getFactura();
                    detalleFacturaPlanListNewDetalleFacturaPlan.setFactura(factura);
                    detalleFacturaPlanListNewDetalleFacturaPlan = em.merge(detalleFacturaPlanListNewDetalleFacturaPlan);
                    if (oldFacturaOfDetalleFacturaPlanListNewDetalleFacturaPlan != null && !oldFacturaOfDetalleFacturaPlanListNewDetalleFacturaPlan.equals(factura)) {
                        oldFacturaOfDetalleFacturaPlanListNewDetalleFacturaPlan.getDetalleFacturaPlanList().remove(detalleFacturaPlanListNewDetalleFacturaPlan);
                        oldFacturaOfDetalleFacturaPlanListNewDetalleFacturaPlan = em.merge(oldFacturaOfDetalleFacturaPlanListNewDetalleFacturaPlan);
                    }
                }
            }
            for (ReciboCaja reciboCajaListNewReciboCaja : reciboCajaListNew) {
                if (!reciboCajaListOld.contains(reciboCajaListNewReciboCaja)) {
                    Factura oldFacturaOfReciboCajaListNewReciboCaja = reciboCajaListNewReciboCaja.getFactura();
                    reciboCajaListNewReciboCaja.setFactura(factura);
                    reciboCajaListNewReciboCaja = em.merge(reciboCajaListNewReciboCaja);
                    if (oldFacturaOfReciboCajaListNewReciboCaja != null && !oldFacturaOfReciboCajaListNewReciboCaja.equals(factura)) {
                        oldFacturaOfReciboCajaListNewReciboCaja.getReciboCajaList().remove(reciboCajaListNewReciboCaja);
                        oldFacturaOfReciboCajaListNewReciboCaja = em.merge(oldFacturaOfReciboCajaListNewReciboCaja);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = factura.getIdFactura();
                if (findFactura(id) == null) {
                    throw new NonexistentEntityException("The factura with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Factura factura;
            try {
                factura = em.getReference(Factura.class, id);
                factura.getIdFactura();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The factura with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<DetalleFacturaArticulo> detalleFacturaArticuloListOrphanCheck = factura.getDetalleFacturaArticuloList();
            for (DetalleFacturaArticulo detalleFacturaArticuloListOrphanCheckDetalleFacturaArticulo : detalleFacturaArticuloListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Factura (" + factura + ") cannot be destroyed since the DetalleFacturaArticulo " + detalleFacturaArticuloListOrphanCheckDetalleFacturaArticulo + " in its detalleFacturaArticuloList field has a non-nullable factura field.");
            }
            List<Comision> comisionListOrphanCheck = factura.getComisionList();
            for (Comision comisionListOrphanCheckComision : comisionListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Factura (" + factura + ") cannot be destroyed since the Comision " + comisionListOrphanCheckComision + " in its comisionList field has a non-nullable factura field.");
            }
            List<DetalleFacturaPlan> detalleFacturaPlanListOrphanCheck = factura.getDetalleFacturaPlanList();
            for (DetalleFacturaPlan detalleFacturaPlanListOrphanCheckDetalleFacturaPlan : detalleFacturaPlanListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Factura (" + factura + ") cannot be destroyed since the DetalleFacturaPlan " + detalleFacturaPlanListOrphanCheckDetalleFacturaPlan + " in its detalleFacturaPlanList field has a non-nullable factura field.");
            }
            List<ReciboCaja> reciboCajaListOrphanCheck = factura.getReciboCajaList();
            for (ReciboCaja reciboCajaListOrphanCheckReciboCaja : reciboCajaListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Factura (" + factura + ") cannot be destroyed since the ReciboCaja " + reciboCajaListOrphanCheckReciboCaja + " in its reciboCajaList field has a non-nullable factura field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Usuario usuario = factura.getUsuario();
            if (usuario != null) {
                usuario.getFacturaList().remove(factura);
                usuario = em.merge(usuario);
            }
            Usuario usuario1 = factura.getUsuario1();
            if (usuario1 != null) {
                usuario1.getFacturaList().remove(factura);
                usuario1 = em.merge(usuario1);
            }
            PuntoVenta puntoVenta = factura.getPuntoVenta();
            if (puntoVenta != null) {
                puntoVenta.getFacturaList().remove(factura);
                puntoVenta = em.merge(puntoVenta);
            }
            TipoPlazoPago tipoPlazoPago = factura.getTipoPlazoPago();
            if (tipoPlazoPago != null) {
                tipoPlazoPago.getFacturaList().remove(factura);
                tipoPlazoPago = em.merge(tipoPlazoPago);
            }
            Cliente cliente = factura.getCliente();
            if (cliente != null) {
                cliente.getFacturaList().remove(factura);
                cliente = em.merge(cliente);
            }
            Empleado empleado = factura.getEmpleado();
            if (empleado != null) {
                empleado.getFacturaList().remove(factura);
                empleado = em.merge(empleado);
            }
            em.remove(factura);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Factura> findFacturaEntities() {
        return findFacturaEntities(true, -1, -1);
    }

    public List<Factura> findFacturaEntities(int maxResults, int firstResult) {
        return findFacturaEntities(false, maxResults, firstResult);
    }

    private List<Factura> findFacturaEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Factura.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Factura findFactura(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Factura.class, id);
        } finally {
            em.close();
        }
    }

    public int getFacturaCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Factura> rt = cq.from(Factura.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
